<?php
//TODO Personnaliser la page d'accès interdit
/**
 *
 * La class GlobalBO est le point d'entrée dans le module backoffice.
 * Pour l'activer il faut ajouter la route suivante dans routes.conf.php.
 * $route['*']['/admin/:module/:ctrl/:action'] = array('[example]GlobalBO', 'redirect');
 * La méthode redirect() se charge de charger le bon module :module et d'appeler le bon controller :ctrl
 * et la bonne méthode :action
 * Pour charger un module Doo::app()->getModule($this->params['module'], $this->params['controller'], $this->params['method']);
 *
 * @author Romain Dubos
 */

class GlobalBO extends DooController{

  private $current_module;
  private $current_controller;


  public function __construct(){
    $this->view()->setTagClass("TemplateTag", "globalbo");
  }

  /**
   *
   * Gère la page et le mécanisme d'identification
   */
  public function authentification(){
    if($this->isConnected()){
      $this->index();
      return;
    }
    $data['title'] = "Authentification";
    $data['SITE'] = "NOM DU SITE A CHANGER";
    $data['baseurl'] = Doo::conf()->APP_URL;
    //On charge le plugin Form
    Doo::loadPlugin('Form', 'globalbo');
    //L'action du formulaire
    $action = Doo::conf()->APP_URL."admin";
    //On charge le contenu du formulaire
    $form = formauthentification($action);
    $data['form'] = $form->render();

    //Lors de la soumission du formualaire
    if($this->isPost()){
      if ($form->isValid($_POST)) {
        Doo::loadModel('GlboUser');
        $user = New GlboUser();
        $user->usr_login = $_POST['login'];

        $r = $this->db()->find($user, array('limit'=>1));
        //On check la présence login et la correspondance passwd
        if($r == TRUE && $r->usr_passwd == md5($_POST['passwd'])){
          $_SESSION['user'] = $r->usr_name;
          $_SESSION['login'] = 'admin';
          $_SESSION ['id'] = $r->usr_id;
          $_SESSION['connected'] = TRUE;
          Doo::loadController('AccessManager');
          //Initialise une varible de session $_SESSION['accessRight'] avec les droits d'accès
          $accessManager = new AccessManager($_SESSION ['id']);
          $this->index();
          return;

        }else{
          echo "<div class='error'>Utilisateur inconnu</div>";
        }
      }
    }

    //On réaffiche la page d'authentification lors du première affichage & lors d'une erreur de connexion
    $this->view()->render('authentification', $data);
  }

  /**
   *
   * Gère la déconnexion et la rédirection vers la page de login
   */
  public function deconnexion(){
    unset($_SESSION['connected']);
    unset($_SESSION);
    session_destroy();
    $this->authentification();
  }

  /**
   *
   * Page d'accueil du backoffice identifié
   * Contient le dashboard avec les widget de chaque module
   */
  public function index(){
    if(!$this->isConnected()){
      $this->authentification();
      return;
    }
    //var_dump(Doo::conf()->TEMPLATE_GLOBAL_TAGS);
    $data['title'] = "Authentification";
    $data['SITE'] = "NOM DU SITE A CHANGER";
    $data['baseurl'] = Doo::conf()->APP_URL;
    $data['user'] = $_SESSION['user'];

    //Affichage des widgets
    //Un widget est accessible seulement si le module est autorisé dans L'AcessManager
    Doo::loadController('AccessManager');
    $accessManager = new AccessManager($_SESSION['id']);
    $name = $accessManager->getAccessModule();
    //On initialise la barre de menu
    $data['accessRight'] = $accessManager->getAccessRight();
    //L'utilisateur a accès à des modules
    if($name != null){
      foreach ($name as $module_folder) {
        $moduleWidget = $this->getModuleFunction($module_folder, $module_folder.'_MainController', 'getWidget');
        $widget[$module_folder] =
        Array(
			'url' 			=> $accessManager->getURL($module_folder),
			'title' 		=> $moduleWidget['title'],
			'contentTitle' 	=> $moduleWidget['contentTitle'],
			'content'		=>	$moduleWidget['content'],
			'properties' 	=> $moduleWidget['properties']
        );
      }
      $data['widget'] = $widget;
    }
    $this->view()->render('index', $data, true, TRUE);
  }

  /**
   *
   *  Redirige les appels d'URL vers le bon module/controleur/method
   *  Affiche le résultat si module/controleur/method est bien chargé dans ModuleBase
   *  Les modules peuvent accéder à leurs paramètres via $this->param[O, 1, 2, etc.]
   *  La page d'erreur 404 sinon
   */
  public function redirect(){
    if(empty($this->params['module'])){
      $this->authentification();
      return ;
    }
    $param_module = $this->params['module'];
    $param_controller = $this->params['controller'];
    $param_method = $this->params['method'];
    Doo::loadModel('ModuleBase');
    $moduleBase = new ModuleBase();
    //Si l'utilisateur n'est pas connecté on le redirige vers l'écran de login
    if(!$this->isConnected()){
      $this->authentification();
      return;
    }
    //Si le module/controleur/method est bien chargé alors on affiche sa réponse pour l'afficher
    if($moduleBase->isLoad($param_module, $param_controller, $param_method)){
      if($this->isAjax()){
        echo Doo::app()->getModule($param_module, $param_controller, $param_method, $this->params);
        return;
      }
      $data['moduleContent'] = Doo::app()->getModule($param_module, $param_controller, $param_method, $this->params);
      $data['title'] = "Authentification";
      $data['moduleHeader'] = $this->renderModuleHeader(
      GlobalBO::getModuleFunction($param_module, $param_controller, "getModuleHeader"), $param_module);
      $data['SITE'] = "NOM DU SITE A CHANGER";
      $data['baseurl'] = Doo::conf()->APP_URL;
      Doo::loadController('AccessManager');
      $accessManager = new AccessManager($_SESSION['id']);
      $data['accessRight'] = $accessManager->getAccessRight();
      $data['user'] = $_SESSION['user'];
      $this->view()->render('module', $data);
    }else{
      return 404;
    }
  }


  /**
   *
   * Test si l'utilisateur possède une session active sur le serveur
   * @return TRUE si c'est le cas FALSE sinon
   */
  private function isConnected(){
    return (isset($_SESSION['connected']) && $_SESSION['connected'] == 1) ? true : false;
  }

  /**
   *
   * Transforme le rendu de module->getModuleHeader en format html
   * @return String html
   */
  private function renderModuleHeader($header, $moduleFolder="") {
    $str = "";
    foreach ($header as $k=>$v) {
      switch ($k) {
        case "css":
          $str.= '<link rel="stylesheet" type="text/css" href="'.Doo::conf()->APP_URL.'global/css/globalbo/'.$moduleFolder.'/'.$v.'.css" media="screen">';
          break;
        case "js" :
          $str .="Not implemented yet";
          break;

        case "custom" :
          $str .= $v;
          break;
        default:
          $str .="Erreur de chargement";
          break;
      }
      return $str;
    }
  }

  /**
   *
   * Test si la page a été appelée via la méthode POST du protocole HTTP
   * @return TRUE si  c'est via la méthode POST FALSE sinon
   */
  private function isPost() {
    if ($_SERVER['REQUEST_METHOD'] == "POST") return true;
    else return false;
  }

  /**
   *
   * Lance la méthode du controller en paramètre. Permet de pouvoir récupérer des objets
   * @param unknown_type $moduleFolder
   * @param unknown_type $moduleClass
   * @param unknown_type $moduleFunction
   */
  public static function getModuleFunction($moduleFolder, $moduleClass, $moduleFunction){
    Doo::loadControllerAt($moduleClass, $moduleFolder);
    eval('$module = new '.$moduleClass.'();');
    eval('$ret = $module->'.$moduleFunction.'();');
    return $ret;
  }

  public static function getModuleStaticFunction($moduleFolder, $moduleClass, $moduleFunction){
    Doo::loadControllerAt($moduleClass, $moduleFolder);
    eval('$module = '.$moduleClass.'::'.$moduleFunction.'();');
    return $module;
  }
  /**
   *
   * Gestion des préférence du BO
   * @return
   */
  public function options() {
    if(!$this->isConnected()){
      $this->authentification();
      return;
    }
    $data['title'] = "Authentification";
    $data['SITE'] = "NOM DU SITE A CHANGER";
    $data['baseurl'] = Doo::conf()->APP_URL;
    $data['accessRight'] = $_SESSION['accessRight'];
    $data['user'] = $_SESSION['user'];

    switch ($this->params['mod']){
      case "modules" :
        Doo::loadControllerAt("Utils", "globalbo");
        $ls = Utils::ls_dir(Doo::conf()->SITE_PATH."protected/module/", array("hidden"=>"false", "except"=>array("globalbo", "example")));
        foreach ($ls as $value) {
          $functions = GlobalBO::getModuleStaticFunction($value, $value.'_MainController', "getSubMenu");
          //$data["modules"] = "";
          $data["modules"][] = array('name'=>$value, 'functions'=>$functions);
        }
         
        $renderModTab = $this->renderModuleTable($data["modules"]);
        $data['modules'] = $renderModTab['renderTable'];
        $data['maxRow'] = $renderModTab['maxRow'];
        break;
      default:
        Doo::loadModelAt("GlboUser", "globalbo");
        $users = new GlboUser();
        $users = $this->db()->find($users);
        $data['users'] = $users;
        break;
    }


    $this->view()->render('options', $data, true, TRUE);
  }

  private function renderModuleTable($arr){
    $str = array();
    $max_row=0;
    foreach ($arr as $value) {
      $tmp = '<td rowspan="2"> '.$value['name'].'</td>';
      //Calcul le nombre de rowspan pour le th <function>
      if(($siz=sizeof($value['functions'])) > $max_row){
        $max_row = $siz;
      }
      foreach ($value['functions'] as $function) {
        $tmp .= '<td>'.$function.'</td>';
      }
      $tmp .= "<tr>";
      foreach ($value['functions'] as $function) {
        $tmp .= '<td id="'.$value['name'].'-'.$function.'" class="activate"></td>';
      }
      $tmp .= "</tr>";
      $str['renderTable'][] = $tmp;
    }
    $str['maxRow'] = $max_row;
    return $str;

  }
}
?>